Google Cloud Functions: คู่มือฉบับสมบูรณ์สำหรับ HTTP Triggers

Google Cloud Functions (GCF) เป็นสภาพแวดล้อมการประมวลผลแบบไร้เซิร์ฟเวอร์ที่ช่วยให้คุณสร้างและเชื่อมต่อบริการคลาวด์ ด้วย Cloud Functions คุณเขียนฟังก์ชันง่ายๆ ที่มีวัตถุประสงค์เดียวซึ่งเชื่อมโยงกับเหตุการณ์ที่ปล่อยออกมาจากโครงสร้างพื้นฐานและบริการคลาวด์ของคุณ ฟังก์ชันของคุณจะถูกเรียกใช้เมื่อเกิดเหตุการณ์ที่คุณกำลังเฝ้าดู วิธีการนี้ช่วยให้คุณพัฒนาแอปพลิเคชันที่ขับเคลื่อนด้วยเหตุการณ์ได้โดยไม่ต้องจัดการเซิร์ฟเวอร์หรือรันไทม์

หนึ่งในวิธีที่พบบ่อยที่สุดในการเรียกใช้ Cloud Function คือผ่าน HTTP request คู่มือนี้จะเจาะลึกโลกของ HTTP triggers ใน Google Cloud Functions เพื่อให้คุณมีความรู้ในการสร้างแอปพลิเคชันที่ทรงพลัง ปรับขนาดได้ และคุ้มค่า

HTTP Triggers คืออะไร?

HTTP trigger ช่วยให้คุณเรียกใช้ Cloud Function ของคุณเพื่อตอบสนองต่อ HTTP request โดยพื้นฐานแล้ว เมื่อมีการส่ง HTTP request ไปยัง URL เฉพาะ Google Cloud Functions จะเรียกใช้ฟังก์ชันที่เกี่ยวข้องโดยอัตโนมัติ สิ่งนี้ทำให้ HTTP triggers เหมาะอย่างยิ่งสำหรับการสร้าง APIs, webhooks และเว็บแอปพลิเคชันที่ขับเคลื่อนด้วยเหตุการณ์

ประโยชน์หลักของการใช้ HTTP Triggers:

• การปรับขนาด: Cloud Functions จะปรับขนาดโดยอัตโนมัติเพื่อจัดการ HTTP requests ที่เข้ามา คุณไม่ต้องกังวลเกี่ยวกับการจัดเตรียมหรือจัดการเซิร์ฟเวอร์
• ความคุ้มค่า: คุณจ่ายเฉพาะเวลาที่ฟังก์ชันของคุณทำงาน เมื่อฟังก์ชันของคุณไม่ได้ใช้งาน คุณจะไม่เสียค่าใช้จ่าย
• ใช้งานง่าย: Cloud Functions ทำให้กระบวนการพัฒนาและปรับใช้เป็นเรื่องง่าย คุณสามารถมุ่งเน้นไปที่การเขียนโค้ดฟังก์ชันของคุณ และ Google Cloud จะจัดการโครงสร้างพื้นฐาน
• การผสานรวม: HTTP triggers ช่วยให้คุณผสานรวม Cloud Functions ของคุณกับบริการอื่นๆ ได้อย่างง่ายดาย เช่น เว็บแอปพลิเคชัน แอปมือถือ และ APIs ของบุคคลที่สาม

การสร้าง Cloud Function ด้วย HTTP Trigger

เราจะมาดูขั้นตอนการสร้าง Cloud Function ง่ายๆ ด้วย HTTP trigger เราจะสร้างฟังก์ชันที่ตอบกลับด้วยข้อความ "Hello, World!" ตัวอย่างนี้สามารถปรับเปลี่ยนได้สำหรับภาษาท้องถิ่นทั่วโลกต่างๆ โดยการแก้ไขสตริงผลลัพธ์

สิ่งที่ต้องมี:

• บัญชี Google Cloud Platform (GCP)
• Google Cloud SDK (gcloud) ติดตั้งและกำหนดค่าแล้ว

ขั้นตอน:

1. สร้างโปรเจกต์ใหม่ (หากคุณยังไม่มี):

   หากคุณยังไม่มี GCP project โปรดสร้างใน Google Cloud Console

2. เปิดใช้งาน Cloud Functions API:

   ใน Cloud Console ไปที่ Cloud Functions API และเปิดใช้งาน

3. สร้างไดเร็กทอรีสำหรับฟังก์ชัน:

   สร้างไดเร็กทอรีใหม่สำหรับ Cloud Function ของคุณ ตัวอย่างเช่น:

               mkdir hello-http
   cd hello-http
               
   
                 
                   Copy
                 
               
             

4. เขียนโค้ดฟังก์ชัน:

   สร้างไฟล์ชื่อ `main.py` (หรือ `index.js` สำหรับ Node.js) ด้วยโค้ดต่อไปนี้:

   Python (main.py):

               def hello_http(request):
       """HTTP Cloud Function.
       Args:
           request (flask.Request): The request object.
           
       Returns:
           The response text, or any set of values that can be turned into a
           Response object using `make_response`
           `.
       """
       request_json = request.get_json(silent=True)
       request_args = request.args
   
       if request_json and 'name' in request_json:
           name = request_json['name']
       elif request_args and 'name' in request_args:
           name = request_args['name']
       else:
           name = 'World'
       return f'Hello, {name}!'
               
   
                 
                   Copy
                 
               
             

   Node.js (index.js):

               exports.helloHttp = (req, res) => {
     let name = 'World';
     if (req.body.name) {
       name = req.body.name;
     } else if (req.query.name) {
       name = req.query.name;
     }
     res.status(200).send(`Hello, ${name}!`);
   };
   
               
   
                 
                   Copy
                 
               
             

5. สร้างไฟล์ Requirements (เฉพาะ Python):

   หากคุณใช้ Python ให้สร้างไฟล์ชื่อ `requirements.txt` และเพิ่ม dependencies ที่ฟังก์ชันของคุณต้องการ สำหรับตัวอย่างนี้ สิ่งนี้ไม่จำเป็นอย่างยิ่ง แต่ก็เป็นแนวทางปฏิบัติที่ดีในการรวมไว้ คุณสามารถปล่อยให้ว่างได้หากคุณไม่มี dependencies

6. ปรับใช้ฟังก์ชัน:

   ใช้คำสั่ง `gcloud functions deploy` เพื่อปรับใช้ฟังก์ชันของคุณ แทนที่ `YOUR_FUNCTION_NAME` ด้วยชื่อที่ต้องการสำหรับฟังก์ชันของคุณ

   Python:

               gcloud functions deploy YOUR_FUNCTION_NAME \
       --runtime python39 \
       --trigger-http \
       --allow-unauthenticated
               
   
                 
                   Copy
                 
               
             

   Node.js:

               gcloud functions deploy YOUR_FUNCTION_NAME \
       --runtime nodejs16 \
       --trigger-http \
       --allow-unauthenticated
               
   
                 
                   Copy
                 
               
             

   คำอธิบายพารามิเตอร์:

   • `YOUR_FUNCTION_NAME`: ชื่อที่คุณต้องการตั้งให้กับ Cloud Function ของคุณ
   • `--runtime`: สภาพแวดล้อมรันไทม์สำหรับฟังก์ชันของคุณ (เช่น `python39`, `nodejs16`)
   • `--trigger-http`: ระบุว่าฟังก์ชันควรถูกเรียกใช้โดย HTTP requests
   • `--allow-unauthenticated`: อนุญาตให้ใครก็ตามเรียกใช้ฟังก์ชันได้โดยไม่ต้องมีการยืนยันตัวตน คำเตือน: ใช้ความระมัดระวังเมื่อเปิดใช้งานสิ่งนี้ในสภาพแวดล้อมการผลิต! พิจารณาการใช้การยืนยันตัวตนและการอนุญาตที่เหมาะสม
7. ทดสอบฟังก์ชัน:

   หลังจากการปรับใช้ คำสั่ง `gcloud` จะแสดง URL ของฟังก์ชันของคุณ จากนั้นคุณสามารถทดสอบได้โดยการส่ง HTTP request ไปยัง URL นั้นโดยใช้เครื่องมือเช่น `curl` หรือ Postman

               curl YOUR_FUNCTION_URL
               
   
                 
                   Copy
                 
               
             

   คุณควรเห็นข้อความ "Hello, World!" ในการตอบกลับ คุณยังสามารถส่งชื่อเป็นพารามิเตอร์ query ได้:

               curl "YOUR_FUNCTION_URL?name=YourName"
               
   
                 
                   Copy
                 
               
             

   สิ่งนี้ควรตอบกลับ "Hello, YourName!"

การทำความเข้าใจ HTTP Request และ Response

เมื่อ Cloud Function ถูกเรียกใช้โดย HTTP request ฟังก์ชันจะได้รับ object ที่มีข้อมูลเกี่ยวกับ request โดยทั่วไป object นี้จะรวมถึง:

• Headers: HTTP headers ที่ส่งมาพร้อมกับ request
• Body: ส่วน body ของ request (เช่น ข้อมูล JSON, ข้อมูล form)
• Query Parameters: พารามิเตอร์ที่ส่งผ่าน URL
• Method: HTTP method (เช่น GET, POST, PUT, DELETE)

ฟังก์ชันของคุณควรส่งคืน HTTP response ซึ่งรวมถึง:

• Status Code: HTTP status code (เช่น 200 OK, 400 Bad Request, 500 Internal Server Error)
• Headers: HTTP headers ที่จะส่งไปพร้อมกับการตอบกลับ
• Body: ส่วน body ของการตอบกลับ (เช่น ข้อมูล JSON, เนื้อหา HTML)

ตัวอย่าง: การจัดการ HTTP Methods ที่แตกต่างกัน

นี่คือตัวอย่างวิธีการจัดการ HTTP methods ที่แตกต่างกันใน Cloud Function ของคุณ:

Python (main.py):

            from flask import escape

def http_method(request):
    """Responds to any HTTP request.
    Args:
        request (flask.Request): HTTP request object.
    Returns:
        The response text or any set of values that can be turned into a
        Response object using
        `make_response``.
    """
    if request.method == 'GET':
        return 'This is a GET request!'
    elif request.method == 'POST':
        request_json = request.get_json(silent=True)
        if request_json and 'message' in request_json:
            message = escape(request_json['message'])
            return f'This is a POST request with message: {message}'
        else:
            return 'This is a POST request without a message.'
    else:
        return 'Unsupported HTTP method.', 405

            

              
                Copy
              
            
          

Node.js (index.js):

            exports.httpMethod = (req, res) => {
  switch (req.method) {
    case 'GET':
      res.status(200).send('This is a GET request!');
      break;
    case 'POST':
      if (req.body.message) {
        const message = req.body.message;
        res.status(200).send(`This is a POST request with message: ${message}`);
      } else {
        res.status(200).send('This is a POST request without a message.');
      }
      break;
    default:
      res.status(405).send('Unsupported HTTP method!');
      break;
  }
};

            

              
                Copy
              
            
          

อย่าลืมปรับใช้ฟังก์ชันที่อัปเดตโดยใช้คำสั่ง `gcloud functions deploy`

การรักษาความปลอดภัย HTTP Triggers ของคุณ

ความปลอดภัยเป็นสิ่งสำคัญสูงสุดเมื่อทำงานกับ HTTP triggers โดยเฉพาะอย่างยิ่งเมื่อเกี่ยวข้องกับข้อมูลที่ละเอียดอ่อนหรือการดำเนินงานที่สำคัญ นี่คือข้อควรพิจารณาด้านความปลอดภัยที่สำคัญ:

การยืนยันตัวตนและการอนุญาต

โดยค่าเริ่มต้น Cloud Functions ที่ถูกเรียกใช้โดย HTTP สามารถเข้าถึงได้แบบสาธารณะหากคุณใช้ `--allow-unauthenticated` ในสถานการณ์การผลิตส่วนใหญ่ คุณจะต้องจำกัดการเข้าถึงเฉพาะผู้ใช้หรือบริการที่ได้รับอนุญาต Google Cloud มีตัวเลือกมากมายสำหรับการยืนยันตัวตนและการอนุญาต:

• Identity-Aware Proxy (IAP): IAP ช่วยให้คุณควบคุมการเข้าถึง Cloud Functions ของคุณตามข้อมูลประจำตัวของ Google โดยต้องให้ผู้ใช้ยืนยันตัวตนด้วยบัญชี Google ของตนก่อนที่จะเข้าถึงฟังก์ชัน
• Service Accounts: คุณสามารถกำหนด service account ให้กับ Cloud Function ของคุณ และใช้เพื่อยืนยันตัวตนกับบริการ Google Cloud อื่นๆ ได้ สิ่งนี้มีประโยชน์เพื่อให้ฟังก์ชันของคุณเข้าถึงทรัพยากร เช่น Cloud Storage หรือ Cloud Datastore
• การยืนยันตัวตนแบบกำหนดเอง: คุณสามารถใช้กลไกการยืนยันตัวตนของคุณเอง เช่น JWT (JSON Web Token) หรือ API keys ซึ่งให้ความยืดหยุ่นสูงสุดแก่คุณ แต่ก็ต้องใช้ความพยายามในการพัฒนามากขึ้นเช่นกัน

การตรวจสอบความถูกต้องของข้อมูลขาเข้า

ตรวจสอบข้อมูลขาเข้าที่ได้รับจาก Cloud Function ของคุณเสมอ เพื่อป้องกันช่องโหว่ด้านความปลอดภัย เช่น SQL injection หรือ cross-site scripting (XSS) ใช้เทคนิคการทำให้บริสุทธิ์และหลีกเลี่ยงที่เหมาะสมเพื่อป้องกันข้อมูลขาเข้าที่เป็นอันตราย

HTTPS

ตรวจสอบให้แน่ใจว่า Cloud Function ของคุณสามารถเข้าถึงได้ผ่าน HTTPS เท่านั้น เพื่อเข้ารหัสการสื่อสารระหว่างไคลเอ็นต์และฟังก์ชัน Google Cloud Functions ให้ endpoints HTTPS โดยอัตโนมัติ

การจำกัดอัตรา

ใช้การจำกัดอัตราเพื่อป้องกันการใช้งานในทางที่ผิดและการโจมตีแบบ denial-of-service (DoS) คุณสามารถใช้บริการเช่น Google Cloud Armor เพื่อปกป้อง Cloud Functions ของคุณจากการรับส่งข้อมูลที่มากเกินไป

กรณีการใช้งานสำหรับ HTTP Triggers

HTTP triggers มีความหลากหลายและสามารถใช้ได้ในหลากหลายแอปพลิเคชัน นี่คือกรณีการใช้งานทั่วไป:

• REST APIs: สร้าง RESTful APIs สำหรับเว็บและแอปพลิเคชันมือถือของคุณ
• Webhooks: ผสานรวมกับบริการของบุคคลที่สามโดยการรับ webhook events
• การประมวลผล Form: ประมวลผลข้อมูลที่ส่งผ่าน HTML forms
• การปรับขนาดรูปภาพ: ทริกเกอร์การปรับขนาดรูปภาพเมื่อมีการอัปโหลดรูปภาพใหม่ไปยัง Cloud Storage
• การแปลงข้อมูล: แปลงข้อมูลจากรูปแบบหนึ่งไปอีกรูปแบบหนึ่ง
• Slack Bots: สร้าง Slack bots ที่โต้ตอบได้
• เว็บแอปพลิเคชันแบบกำหนดเอง: ให้บริการเนื้อหาแบบไดนามิกสำหรับเว็บแอปพลิเคชันขนาดเล็กหรือ microservices

ตัวอย่างในอุตสาหกรรมต่างๆ

• E-commerce (ทั่วโลก): HTTP trigger สามารถใช้เพื่อประมวลผลการชำระเงินจากเกตเวย์การชำระเงินต่างๆ ทั่วโลก ตรวจสอบความถูกต้องของการทำธุรกรรมและอัปเดตสถานะคำสั่งซื้อแบบเรียลไทม์ ฟังก์ชันสามารถใช้ข้อมูล geolocation จาก request เพื่อใช้ภาษีและอัตราค่าจัดส่งที่เหมาะสมตามตำแหน่งของผู้ใช้
• การเงิน (ธนาคารระหว่างประเทศ): HTTP triggers สามารถอำนวยความสะดวกในการโอนเงินที่ปลอดภัยระหว่างบัญชีธนาคารต่างๆ ทั่วโลก จัดการการแปลงสกุลเงิน และปฏิบัติตามกฎระเบียบการธนาคารระหว่างประเทศ การยืนยันตัวตนมีความสำคัญอย่างยิ่งในที่นี้ ซึ่งอาจเกี่ยวข้องกับการยืนยันตัวตนหลายปัจจัยผ่าน SMS หรือแอป authenticator
• การดูแลสุขภาพ (Telemedicine): HTTP trigger สามารถจัดการคำขอการนัดหมายจากผู้ป่วยทั่วโลก ประสานงานกับเขตเวลาต่างๆ และจัดการความพร้อมของแพทย์ นอกจากนี้ยังสามารถผสานรวมกับบริการแปลภาษาเพื่อรองรับหลายภาษาได้ ความเป็นส่วนตัวของข้อมูลและการปฏิบัติตามกฎระเบียบ เช่น HIPAA (ในสหรัฐอเมริกา) หรือ GDPR (ในยุโรป) มีความสำคัญสูงสุด
• การศึกษา (แพลตฟอร์มการเรียนรู้ออนไลน์): HTTP triggers สามารถใช้เพื่อตรวจการบ้านโดยอัตโนมัติ โดยให้ข้อเสนอแนะทันทีแก่นักเรียนโดยไม่คำนึงถึงตำแหน่งที่ตั้งของพวกเขา นอกจากนี้ยังสามารถทริกเกอร์คำแนะนำการเรียนรู้ส่วนบุคคลตามผลการเรียนของนักเรียน
• โลจิสติกส์ (การจัดส่งทั่วโลก): HTTP triggers สามารถใช้เพื่อติดตามการจัดส่งแบบเรียลไทม์ ให้การอัปเดตเกี่ยวกับตำแหน่งพัสดุและเวลาจัดส่งโดยประมาณแก่ลูกค้าทั่วโลก การผสานรวมกับผู้ให้บริการจัดส่งต่างๆ โดยใช้ APIs ของพวกเขาผ่าน HTTP triggers เป็นเรื่องปกติ

เทคนิคขั้นสูง

การใช้ Environment Variables

Environment variables ช่วยให้คุณกำหนดค่า Cloud Function ของคุณได้โดยไม่ต้อง hardcode ข้อมูลที่ละเอียดอ่อนหรือค่าการกำหนดค่าในโค้ดของคุณ คุณสามารถตั้งค่า environment variables โดยใช้คำสั่ง `gcloud functions deploy` หรือใน Google Cloud Console

            gcloud functions deploy YOUR_FUNCTION_NAME \
    --runtime python39 \
    --trigger-http \
    --set-env-vars API_KEY=YOUR_API_KEY,DATABASE_URL=YOUR_DATABASE_URL
            

              
                Copy
              
            
          

ในโค้ดของคุณ คุณสามารถเข้าถึง environment variables โดยใช้ dictionary `os.environ` (Python) หรือ object `process.env` (Node.js)

Python:

            import os

def your_function(request):
    api_key = os.environ.get('API_KEY')
    # Use the API key in your function
    return f'API Key: {api_key}'

            

              
                Copy
              
            
          

Node.js:

            exports.yourFunction = (req, res) => {
  const apiKey = process.env.API_KEY;
  // Use the API key in your function
  res.status(200).send(`API Key: ${apiKey}`);
};

            

              
                Copy
              
            
          

การจัดการงานแบบอะซิงโครนัส

สำหรับงานที่ใช้เวลานานหรืองานที่ต้องใช้การคำนวณมาก ควรใช้การประมวลผลแบบอะซิงโครนัสเพื่อหลีกเลี่ยงการบล็อก HTTP request คุณสามารถใช้บริการเช่น Google Cloud Tasks หรือ Cloud Pub/Sub เพื่อถ่ายโอนงานเหล่านี้ไปยังคิวแยกต่างหาก

การจัดการข้อผิดพลาดและการบันทึก

ใช้การจัดการข้อผิดพลาดและการบันทึกที่มีประสิทธิภาพใน Cloud Functions ของคุณเพื่อระบุและแก้ไขปัญหาได้อย่างรวดเร็ว ใช้ Google Cloud Logging เพื่อรวบรวมบันทึกจากฟังก์ชันของคุณและตรวจสอบประสิทธิภาพของฟังก์ชัน

แนวทางปฏิบัติที่ดีที่สุด

• ทำให้ฟังก์ชันมีขนาดเล็กและมุ่งเน้น: แต่ละฟังก์ชันควรมีวัตถุประสงค์เดียวที่กำหนดไว้อย่างชัดเจน
• ใช้การจัดการ Dependency: ใช้ตัวจัดการแพ็กเกจเช่น `pip` (Python) หรือ `npm` (Node.js) เพื่อจัดการ dependencies ของคุณ
• ทดสอบฟังก์ชันของคุณอย่างละเอียด: เขียน unit tests และ integration tests เพื่อให้แน่ใจว่าฟังก์ชันของคุณทำงานได้อย่างถูกต้อง
• ตรวจสอบประสิทธิภาพของฟังก์ชัน: ใช้ Google Cloud Monitoring เพื่อติดตามเวลาการทำงานของฟังก์ชัน การใช้หน่วยความจำ และอัตราข้อผิดพลาด
• ปรับโค้ดให้เหมาะสมสำหรับ Cold Starts: ลดเวลาที่ฟังก์ชันของคุณใช้ในการเริ่มต้น (cold start) สิ่งนี้สามารถทำได้โดยการลด dependencies, การปรับโค้ดให้เหมาะสม และการใช้ provisioned concurrency (เมื่อมี)
• พิจารณาตำแหน่งของฟังก์ชัน: ปรับใช้ฟังก์ชันของคุณในภูมิภาคที่ใกล้กับผู้ใช้ของคุณทางภูมิศาสตร์เพื่อลดความหน่วงแฝง สำหรับผู้ชมทั่วโลก พิจารณาการปรับใช้ในหลายภูมิภาค

การแก้ไขปัญหาทั่วไป

• ฟังก์ชันไม่สามารถปรับใช้ได้: ตรวจสอบข้อผิดพลาดทางไวยากรณ์ในโค้ดของคุณ ตรวจสอบให้แน่ใจว่าคุณมีสิทธิ์ที่จำเป็น และตรวจสอบว่าคุณใช้สภาพแวดล้อมรันไทม์ที่รองรับ
• ฟังก์ชันคืนค่าข้อผิดพลาด 500: ตรวจสอบบันทึกของฟังก์ชันใน Google Cloud Logging สำหรับข้อความแสดงข้อผิดพลาด สาเหตุทั่วไป ได้แก่ exception ที่ไม่ได้รับการจัดการ dependency ที่ขาดหายไป หรือการกำหนดค่าที่ไม่ถูกต้อง
• ฟังก์ชันหมดเวลา: เพิ่มค่า timeout ของฟังก์ชันใน Google Cloud Console หรือโดยใช้คำสั่ง `gcloud functions deploy` นอกจากนี้ ให้ปรับโค้ดของคุณให้เหมาะสมเพื่อลดเวลาการดำเนินการ
• ฟังก์ชันไม่ถูกทริกเกอร์: ตรวจสอบว่า trigger ถูกกำหนดค่าอย่างถูกต้อง และ HTTP request ถูกส่งไปยัง URL ที่ถูกต้อง

สรุป

Google Cloud Functions พร้อม HTTP triggers มอบวิธีที่ทรงพลังและยืดหยุ่นในการสร้างแอปพลิเคชันแบบไร้เซิร์ฟเวอร์ ด้วยการทำความเข้าใจแนวคิดและเทคนิคที่กล่าวถึงในคู่มือนี้ คุณสามารถใช้ประโยชน์จากพลังของ Cloud Functions เพื่อสร้างโซลูชันที่ปรับขนาดได้ คุ้มค่า และขับเคลื่อนด้วยเหตุการณ์สำหรับผู้ชมทั่วโลก โอบรับการปฏิวัติไร้เซิร์ฟเวอร์และปลดล็อกศักยภาพสูงสุดของแอปพลิเคชันคลาวด์ของคุณ!